package admin

import (
	"context"
	"fmt"
	"geekai/api/dto/request"
	"geekai/api/dto/response"
	"geekai/api/handler"
	"geekai/core"
	"geekai/core/types"
	logger2 "geekai/logger"
	"geekai/model"
	"geekai/utils"
	"github.com/gin-gonic/gin"
	"github.com/go-redis/redis/v8"
	"github.com/golang-jwt/jwt/v5"
	"gorm.io/gorm"
	"time"
)

var log = logger2.GetLogger()

// SuperManagerID 超级管理ID，系统默认的超级管理员用户，不能被删除
const SuperManagerID = 1

// ManagerHandler 管理员模块
type ManagerHandler struct {
	handler.BaseHandler
	redis *redis.Client
}

func NewAdminHandler(app *core.AppServer, db *gorm.DB, client *redis.Client) *ManagerHandler {
	return &ManagerHandler{
		BaseHandler: handler.BaseHandler{DB: db, App: app},
		redis:       client,
	}
}

// Login godoc
// @Summary      后台管理员登陆接口
// @Description  后台管理员登陆接口
// @Tags         后台管理-管理员用户
// @Accept       json
// @Produce      json
// @Param        req   body     request.UserLoginReq  true  "管理员登陆"
// @Success      200  {object}  response.AdminUserLoginResp
// @Router       /api/admin/login [post]
func (h *ManagerHandler) Login(c *gin.Context) {
	var data request.UserLoginReq
	// 获取请求数据
	if err := c.ShouldBindJSON(&data); err != nil {
		utils.ERROR(c, types.InvalidArgs)
		return
	}
	var manager model.AdminUser
	// 查询用户信息
	res := h.DB.Model(&model.AdminUser{}).Where("username = ?", data.Username).First(&manager)
	if res.Error != nil {
		utils.ERROR(c, "请检查用户名或者密码是否填写正确")
		return
	}
	// 使用数据库查询处理的用户密码盐和用户输入的密码进行加密
	password := utils.GenPassword(data.Password, manager.Salt)
	// 判断用户输入的密码和数据库中存储的秘密是否一致
	if password != manager.Password {
		utils.ERROR(c, "用户名或者密码错误")
		return
	}
	// 超级管理员默认ID是 1，判断用户是否被禁用，管理员忽略
	if manager.Id != SuperManagerID && manager.Status == false {
		utils.ERROR(c, "该用户已被禁止登录，请联系超级管理员")
		return
	}
	// 创建token
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
		"user_id": manager.Id,
		"expired": time.Now().Add(time.Second * time.Duration(h.App.Config.Session.MaxAge)).Unix(),
	})
	tokenString, err := token.SignedString([]byte(h.App.Config.AdminSession.SecretKey))
	if err != nil {
		utils.ERROR(c, "生成Token失败："+err.Error())
		return
	}
	// 保存到token到Redis
	key := fmt.Sprintf("admin/%d", manager.Id)
	if _, err := h.redis.Set(context.Background(), key, tokenString, 0).Result(); err != nil {
		utils.ERROR(c, "保存Token失败："+err.Error())
		return
	}
	// 更新最后的登录时间和IP
	manager.LastLoginAt = time.Now().Unix()
	manager.LastLoginIp = c.ClientIP()
	h.DB.Updates(&manager)
	// 返回Token
	var result = &response.AdminUserLoginResp{
		IsSuperAdmin: manager.Id == 1,
		Token:        tokenString,
	}
	utils.SUCCESS(c, result)
}

// Logout godoc
// @Summary      退出登录
// @Description  退出登录
// @Tags         后台管理-管理员用户
// @Accept       json
// @Produce      json
// @Success      200  {object}  types.BizVo{}
// @Router       /api/admin/logout [get]
// @Security AdminApiKeyAuth
func (h *ManagerHandler) Logout(c *gin.Context) {
	key := h.GetUserKey(c)
	if _, err := h.redis.Del(c, key).Result(); err != nil {
		log.Errorf("删除用户存储session失败：%v", err)
	} else {
		utils.SUCCESS(c)
	}
}

// Session godoc
// @Summary      会话检测
// @Description  会话检测
// @Tags         后台管理-管理员用户
// @Accept       json
// @Produce      json
// @Success      200  {object}  types.BizVo{date=model.AdminUser}
// @Router       /api/admin/session [get]
// @Security AdminApiKeyAuth
func (h *ManagerHandler) Session(c *gin.Context) {
	// 获取请求用户的ID
	id := h.GetLoginUserId(c)
	key := fmt.Sprintf("admin/%d", id)
	if _, err := h.redis.Get(context.Background(), key).Result(); err != nil {
		utils.NotAuth(c)
		return
	}
	var manager model.AdminUser
	res := h.DB.Where("id", id).First(&manager)
	if res.Error != nil {
		utils.NotAuth(c)
		return
	}
	utils.SUCCESS(c, manager)
}

// List godoc
// @Summary      数据列表
// @Description  数据列表
// @Tags         后台管理-管理员用户
// @Accept       json
// @Produce      json
// @Success      200  {object}  types.BizVo{date=response.AdminUser}
// @Router       /api/admin/list [get]
// @Security AdminApiKeyAuth
func (h *ManagerHandler) List(c *gin.Context) {
	var items []model.AdminUser
	res := h.DB.Find(&items)
	if res.Error != nil {
		utils.ERROR(c, "查询管理员列表出错：", res.Error.Error())
		return
	}
	users := make([]response.AdminUser, 0)
	for _, item := range items {
		var u response.AdminUser
		err := utils.CopyObject(item, &u)
		if err != nil {
			continue
		}
		u.Id = item.Id
		u.CreatedAt = item.CreatedAt.Unix()
		users = append(users, u)
	}
	utils.SUCCESS(c, users)
}

// Save 添加管理员
// Save godoc
// @Summary      添加管理员
// @Description  添加管理员
// @Tags         后台管理-管理员用户
// @Accept       json
// @Produce      json
// @Param        req   body     request.ManagerUserAddReq  true  "添加管理员"
// @Success      200  {object}  types.BizVo
// @Router       /api/admin/save [post]
// @Security AdminApiKeyAuth
func (h *ManagerHandler) Save(c *gin.Context) {
	var data request.ManagerUserAddReq
	if err := c.ShouldBindJSON(&data); err != nil {
		utils.ERROR(c, types.InvalidArgs)
		return
	}
	var user model.AdminUser
	res := h.DB.Where("username = ?", data.Username).First(&user)
	if res.Error == nil {
		utils.ERROR(c, "用户名已经存在")
		return
	}
	// 生成密码盐
	salt := utils.RandString(8)
	// 生成密码
	password := utils.GenPassword(data.Password, salt)
	res = h.DB.Create(&model.AdminUser{
		Username: data.Username,
		Password: password,
		Salt:     salt,
		Status:   data.Status,
	})
	if res.Error != nil {
		utils.ERROR(c, "添加管理员失败：", res.Error.Error())
		return
	}
	utils.SUCCESS(c)
}

// Remove 添加管理员
// Save godoc
// @Summary      删除管理员
// @Description  删除管理员
// @Tags         后台管理-管理员用户
// @Accept       json
// @Produce      json
// @Param        id   query     int  true  "管理员Id"
// @Success      200  {object}  types.BizVo{}
// @Router       /api/admin/remove [get]
// @Security AdminApiKeyAuth
func (h *ManagerHandler) Remove(c *gin.Context) {
	// 获取前端传递的用户Id
	id := h.GetInt(c, "id", 0)
	if id <= 0 {
		utils.ERROR(c, types.InvalidArgs)
		return
	}
	if id == SuperManagerID {
		utils.ERROR(c, "超级管理员不能删除")
		return
	}
	res := h.DB.Where("id", id).Delete(&model.AdminUser{})
	if res.Error != nil {
		utils.ERROR(c, "删除用户失败："+res.Error.Error())
		return
	}
	utils.SUCCESS(c)
}

// Enable godoc
// @Summary      启用/禁用 用户
// @Description  启用/禁用 用户
// @Tags         后台管理-管理员用户
// @Accept       json
// @Produce      json
// @Param        req   body     request.ManagerUserEnableReq  true  "启用禁用信息"
// @Success      200  {object}  types.BizVo{}
// @Router       /api/admin/enable [post]
// @Security AdminApiKeyAuth
func (h *ManagerHandler) Enable(c *gin.Context) {
	var data request.ManagerUserEnableReq
	if err := c.ShouldBindJSON(&data); err != nil {
		utils.ERROR(c, types.InvalidArgs)
		return
	}
	res := h.DB.Model(&model.AdminUser{}).Where("id", data.Id).UpdateColumn("status", data.Enabled)
	if res.Error != nil {
		utils.ERROR(c, "修改用户状态失败："+res.Error.Error())
		return
	}
	utils.SUCCESS(c)
}

// ResetPass godoc
// @Summary      重置密码
// @Description  重置密码
// @Tags         后台管理-管理员用户
// @Accept       json
// @Produce      json
// @Param        req   body     request.ManagerUserResetPassReq  true  "管理员信息"
// @Success      200  {object}  types.BizVo{}
// @Router       /api/admin/resetPass [post]
// @Security AdminApiKeyAuth
func (h *ManagerHandler) ResetPass(c *gin.Context) {
	// 获取当前请求的用户Id
	userId := h.GetLoginUserId(c)
	// 判断是不是管理员
	if userId != SuperManagerID {
		utils.ERROR(c, "只有管理员才能进行该操作")
		return
	}
	var data request.ManagerUserResetPassReq
	// 获取请求参数
	if err := c.ShouldBindJSON(&data); err != nil {
		utils.ERROR(c, types.InvalidArgs)
		return
	}
	var user model.AdminUser
	// 查询要重置密码的用户
	res := h.DB.Where("id", data.Id).First(&user)
	if res.Error != nil {
		utils.ERROR(c, "查询用户信息失败："+res.Error.Error())
		return
	}
	// 生成加密密码
	password := utils.GenPassword(data.Password, user.Salt)
	user.Password = password
	// 更新用户信息
	res = h.DB.Updates(&user)
	if res.Error != nil {
		utils.ERROR(c, "重置密码失败："+res.Error.Error())
		return
	}
	utils.SUCCESS(c)
}
